<?php
    // +----------------------------------------------------------------------
    // | ThinkPHP [ WE CAN DO IT JUST THINK ]
    // +----------------------------------------------------------------------
    // | Copyright (c) 2006~2017 http://thinkphp.cn All rights reserved.
    // +----------------------------------------------------------------------
    // | Licensed ( http://www.apache.org/licenses/LICENSE-2.0 )
    // +----------------------------------------------------------------------
    // | Author: zhangyajun <448901948@qq.com>
    // +----------------------------------------------------------------------
    namespace think;

    use ArrayAccess;
    use ArrayIterator;
    use Countable;
    use IteratorAggregate;
    use JsonSerializable;

    class Collection implements ArrayAccess, Countable, IteratorAggregate, JsonSerializable {
        protected $items = [];

        public function __construct($items = []) {
            $this->items = $this->convertToArray($items);
        }

        /**
         * 转换成数组
         * @param  mixed $items
         * @return array
         */
        protected function convertToArray($items) {
            if ($items instanceof self) {
                return $items->all();
            }
            return (array)$items;
        }

        public function all() {
            return $this->items;
        }

        public static function make($items = []) {
            return new static($items);
        }

        /**
         * 是否为空
         * @return bool
         */
        public function isEmpty() {
            return empty($this->items);
        }

        /**
         * 合并数组
         * @param  mixed $items
         * @return static
         */
        public function merge($items) {
            return new static(array_merge($this->items, $this->convertToArray($items)));
        }

        /**
         * 比较数组，返回差集
         * @param  mixed $items
         * @return static
         */
        public function diff($items) {
            return new static(array_diff($this->items, $this->convertToArray($items)));
        }

        /**
         * 交换数组中的键和值
         * @return static
         */
        public function flip() {
            return new static(array_flip($this->items));
        }

        /**
         * 比较数组，返回交集
         * @param  mixed $items
         * @return static
         */
        public function intersect($items) {
            return new static(array_intersect($this->items, $this->convertToArray($items)));
        }

        /**
         * 返回数组中所有的键名
         * @return static
         */
        public function keys() {
            return new static(array_keys($this->items));
        }

        /**
         * 删除数组的最后一个元素（出栈）
         * @return mixed
         */
        public function pop() {
            return array_pop($this->items);
        }

        /**
         * 通过使用用户自定义函数，以字符串返回数组
         * @param  callable $callback
         * @param  mixed    $initial
         * @return mixed
         */
        public function reduce(callable $callback, $initial = null) {
            return array_reduce($this->items, $callback, $initial);
        }

        /**
         * 以相反的顺序返回数组。
         * @return static
         */
        public function reverse() {
            return new static(array_reverse($this->items));
        }

        /**
         * 删除数组中首个元素，并返回被删除元素的值
         * @return mixed
         */
        public function shift() {
            return array_shift($this->items);
        }

        /**
         * 把一个数组分割为新的数组块.
         * @param  int  $size
         * @param  bool $preserveKeys
         * @return static
         */
        public function chunk($size, $preserveKeys = false) {
            $chunks = [];
            foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
                $chunks[] = new static($chunk);
            }
            return new static($chunks);
        }

        /**
         * 在数组开头插入一个元素
         * @param mixed $value
         * @param null  $key
         * @return int
         */
        public function unshift($value, $key = null) {
            if (is_null($key)) {
                array_unshift($this->items, $value);
            } else {
                $this->items = [$key => $value] + $this->items;
            }
        }

        /**
         * 给每个元素执行个回调
         * @param  callable $callback
         * @return $this
         */
        public function each(callable $callback) {
            foreach ($this->items as $key => $item) {
                if ($callback($item, $key) === false) {
                    break;
                }
            }
            return $this;
        }

        /**
         * 用回调函数过滤数组中的元素
         * @param callable|null $callback
         * @return static
         */
        public function filter(callable $callback = null) {
            if ($callback) {
                return new static(array_filter($this->items, $callback));
            }
            return new static(array_filter($this->items));
        }

        /**
         * 返回数组中指定的一列
         * @param      $column_key
         * @param null $index_key
         * @return array
         */
        public function column($column_key, $index_key = null) {
            if (function_exists('array_column')) {
                return array_column($this->items, $column_key, $index_key);
            }
            $result = [];
            foreach ($this->items as $row) {
                $key    = $value = null;
                $keySet = $valueSet = false;
                if (null !== $index_key && array_key_exists($index_key, $row)) {
                    $keySet = true;
                    $key    = (string)$row[$index_key];
                }
                if (null === $column_key) {
                    $valueSet = true;
                    $value    = $row;
                } elseif (is_array($row) && array_key_exists($column_key, $row)) {
                    $valueSet = true;
                    $value    = $row[$column_key];
                }
                if ($valueSet) {
                    if ($keySet) {
                        $result[$key] = $value;
                    } else {
                        $result[] = $value;
                    }
                }
            }
            return $result;
        }

        /**
         * 对数组排序
         * @param  callable|null $callback
         * @return static
         */
        public function sort(callable $callback = null) {
            $items = $this->items;
            $callback ? uasort($items, $callback) : uasort($items, function ($a, $b) {
                if ($a == $b) {
                    return 0;
                }
                return ($a < $b) ? -1 : 1;
            }
            );
            return new static($items);
        }

        /**
         * 将数组打乱
         * @return static
         */
        public function shuffle() {
            $items = $this->items;
            shuffle($items);
            return new static($items);
        }

        /**
         * 截取数组
         * @param  int  $offset
         * @param  int  $length
         * @param  bool $preserveKeys
         * @return static
         */
        public function slice($offset, $length = null, $preserveKeys = false) {
            return new static(array_slice($this->items, $offset, $length, $preserveKeys));
        }

        // ArrayAccess
        public function offsetExists($offset) {
            return array_key_exists($offset, $this->items);
        }

        public function offsetGet($offset) {
            return $this->items[$offset];
        }

        public function offsetSet($offset, $value) {
            if (is_null($offset)) {
                $this->items[] = $value;
            } else {
                $this->items[$offset] = $value;
            }
        }

        public function offsetUnset($offset) {
            unset($this->items[$offset]);
        }

        //Countable
        public function count() {
            return count($this->items);
        }

        //IteratorAggregate
        public function getIterator() {
            return new ArrayIterator($this->items);
        }

        //JsonSerializable
        public function jsonSerialize() {
            return $this->toArray();
        }

        public function toArray() {
            return array_map(function ($value) {
                return ($value instanceof Model || $value instanceof self) ? $value->toArray() : $value;
            }, $this->items
            );
        }

        public function __toString() {
            return $this->toJson();
        }

        /**
         * 转换当前数据集为JSON字符串
         * @access public
         * @param integer $options json参数
         * @return string
         */
        public function toJson($options = JSON_UNESCAPED_UNICODE) {
            return json_encode($this->toArray(), $options);
        }
    }
